import { get, post, put, ax_delete } from '../axios'
import uri from './uri'

let id = 1

export default {
    addUser(param) {
        return post(uri.addUser, param)
    },
    /* 资源管理 */
    //获取hdfs资源列表
    getResHDFSList(param){
        return post(uri.getResHDFSList, param)
    },
    //新建hdfs资源
    postResHdfs(param){
        return post(uri.postResHdfs, param)
    },
    //新建hdfs资源Test
    postResHdfsTest(param){
        return post(uri.postResHdfsTest, param)
    },
    //删除hdfs资源
    delResHDFS(param){
        return ax_delete(uri.delResHDFS, param)
    },
    //删除hdfs资源Test
    delResHDFSTest(param){
        return ax_delete(uri.delResHDFSTest, param)
    },
    //修改hdfs资源
    modifyHDFS(param){
        return post(uri.modifyHDFS, param)
    },
    //分配hdfs资源
    distributeHDFS(param){
        return post(uri.distributeHDFS, param)
    },
    //分享hdfs资源
    shareResHdfs(param){
        return post(uri.shareResHdfs, param)
    },
    // 查询剩余配额
    getHdfsRemain(param){
        return get(uri.getHdfsRemain, param)
    },
    // 查询文件
    getFileNum(param){
        return get(uri.getFileRemain, param)
    },
    // 查询hbase列表
    getResHBASEList(param){
        return post(uri.getResHBASEList, param)
    },
    // 新建hbase资源
    postResHBASE(param){
        return post(uri.postResHBASE, param)
    },
    // 新建hbase资源Test
    postResHBASETest(param){
        return post(uri.postResHBASETest, param)
    },
    // 删除hbase资源
    delHBASERes(param){
        return ax_delete(uri.delHBASERes, param)
    },
    // 删除hbase资源Test
    delHBASEResTest(param){
        return ax_delete(uri.delHBASEResTest, param)
    },
    //分配hbase资源
    distributeHBASE(param){
        return post(uri.distributeHBASE, param)
    },
    //分享hdfs资源
    shareResHBASE(param){
        return post(uri.shareResHBASE, param)
    },
    // hive资源列表
    getResHIVEList(param){
        return post(uri.getResHIVEList, param)
    },
    // 新建hive资源
    postResHIVE(param){
        return post(uri.postResHIVE, param)
    },
    // 新建hive资源Test
    postResHIVETest(param){
        return post(uri.postResHIVETest, param)
    },
    // 删除hive资源
    delHIVERes(param){
        return ax_delete(uri.delHIVERes, param)
    },
    // 删除hive资源Test
    delHIVEResTest(param){
        return ax_delete(uri.delHIVEResTest, param)
    },
    // 分配hive资源
    distributeHIVE(param){
        return post(uri.distributeHIVE, param)
    },
    // 分享hive资源
    shareResHIVE(param){
        return post(uri.shareResHIVE, param)
    },
    // 同步hive资源
    syncHIVE(param){
        return get(uri.syncHIVE, param)
    },
    // 获取可修改权限的人员
    getAuthList(param){
        return get(uri.getAuthList, param)
    },
    // 获取yarn列表
    getResYARNList(param){
        return post(uri.getResYARNList, param)
    },
    // 新建yarn资源
    postResYARN(param){
        return post(uri.postResYARN, param)
    },
    // 新建yarn资源
    postResYARNTest(param){
        return post(uri.postResYARNTest, param)
    },
    modifyYARN(param){
        return post(uri.modifyYARN, param)
    },
    // 删除yarn资源
    delYARNRes(param){
        return ax_delete(uri.delYARNRes, param)
    },
    // 删除yarn资源
    delYARNResTest(param){
        return ax_delete(uri.delYARNResTest, param)
    },
    // 分配yarn资源
    distributeYARN(param){
        return post(uri.distributeYARN, param)
    },
    // 分享yarn资源
    shareResYARN(param){
        return post(uri.shareResYARN, param)
    },
    // 同步yarn资源
    syncYARN(param){
        return get(uri.syncYARN, param)
    },
    // 请求所有队列
    queueList(param){
        return get(uri.queueList, param)
    },
    // kafka 列表
    getResKafkaList(param){
        return post(uri.getResKafkaList, param)
    },
    // 新建kafka
    postResKafka(param){
        return post(uri.postResKafka, param)
    },
    // 新建kafka
    postResKafkaTest(param){
        return post(uri.postResKafkaTest, param)
    },
    // 删除kafka
    delKafka(param){
        return ax_delete(uri.delKafka, param)
    },
    // 删除kafka
    delKafkaTest(param){
        return ax_delete(uri.delKafkaTest, param)
    },
    // 分配kafka
    distributeKafka(param){
        return post(uri.distributeKafka, param)
    },
    // 同步kafka资源
    syncKAFKA(){
        return get(uri.syncKAFKA)
    },
    // 获取kafka 最大副本数
    getReplicationNum(){
        return get(uri.getReplicationNum)
    },

    /* 租户管理start */
    getTenantList(param) { // 获取租户列表
        return get(uri.getTenantList, param)
    },
    addTenant(data, config) { // 新建租户
        return post(uri.addTenant, data, config)
    },
    addTenantTest(data, config) { // 新建租户Test
        return post(uri.addTenantTest, data, config)
    },
    updateTenant(data) { // 编辑租户
        return put(uri.updateTenant, data)
    },
    getTenantDetail(param) {
        return get(uri.getTenantDetail, param)
    },
    changeTenantPwd(data) { // 修改租户密码
        return put(uri.changeTenantPwd, data)
    },
    deleteTenant(param) { // 删除租户
        return ax_delete(uri.delTenant, param)
    },
    deleteTenantTest(param) { // 删除租户Test
        return ax_delete(uri.delTenantTest, param)
    },
    addResource(data) { // 添加资源组件
        return post(uri.addResource, data)
    },
    addResourceTest(data) { // 添加资源组件Test
        return post(uri.addResourceTest, data)
    },
    getResource(param) { // 获取租户已配置的组件
        return get(uri.getResource, param)
    },
    updateResource(data) { // 修改组件配额信息
        return put(uri.updateResource, data)
    },
    downloadKeytab(param) { // 下载keytab文件
        return get(uri.downloadKeytab, param)
    },
    unlockUser(data) { // 解锁用户
        return post(uri.unlockUser, data)
    },
    getResourceStat(param) { // 获取资源统计信息
        return get(uri.getResourceStat, param)
    }
    /* 租户管理end */

}
